package xuan.utils.bazi.maps;

import java.util.HashMap;
import java.util.Map;

/**
 * 八字 - 神煞常量
 *
 * @author 善待
 */
public class BaZiShenShaMap {

    /**
     * 太极贵人（年干\日干+其余地支为键）
     */
    public static final Map<String, String> TAI_JI_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'子\午'。乙见'子\午'。丙见'卯\酉'。丁见'卯\酉'。戊见'辰\戌\丑\未'。己见'辰\戌\丑\未'。庚见'寅\亥'。辛见'寅\亥'。壬见'巳\申'。癸见'巳\申'

            二、详解：
                年干\日干是甲，并且其余地支有子\午
                年干\日干是乙，并且其余地支有子\午
                年干\日干是丙，并且其余地支有卯\酉
                年干\日干是丁，并且其余地支有卯\酉
                年干\日干是戊，并且其余地支有辰\戌\丑\未
                年干\日干是己，并且其余地支有辰\戌\丑\未
                年干\日干是庚，并且其余地支有寅\亥
                年干\日干是辛，并且其余地支有寅\亥
                年干\日干是壬，并且其余地支有巳\申
                年干\日干是癸，并且其余地支有巳\申
         */
        {
            put("甲子", "太极贵人");
            put("甲午", "太极贵人");
            put("乙子", "太极贵人");
            put("乙午", "太极贵人");
            put("丙卯", "太极贵人");
            put("丙酉", "太极贵人");
            put("丁卯", "太极贵人");
            put("丁酉", "太极贵人");
            put("戊辰", "太极贵人");
            put("戊戌", "太极贵人");
            put("戊丑", "太极贵人");
            put("戊未", "太极贵人");
            put("己辰", "太极贵人");
            put("己戌", "太极贵人");
            put("己丑", "太极贵人");
            put("己未", "太极贵人");
            put("庚寅", "太极贵人");
            put("庚亥", "太极贵人");
            put("辛寅", "太极贵人");
            put("辛亥", "太极贵人");
            put("壬巳", "太极贵人");
            put("壬申", "太极贵人");
            put("癸巳", "太极贵人");
            put("癸申", "太极贵人");
        }
    };

    /**
     * 天乙贵人（年干\日干+其余地支为键）
     */
    public static final Map<String, String> TIAN_YI_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'丑\未'。乙见'子\申'。丙见'酉\亥'。丁见'酉\亥'。戊见'丑\未'。己见'子\申'。庚见'丑\未'。辛见'寅\午'。壬见'卯\巳'。癸见'卯\巳'

            二、详解：
                年干\日干是甲，并且其余地支有丑\未
                年干\日干是乙，并且其余地支有子\申
                年干\日干是丙，并且其余地支有酉\亥
                年干\日干是丁，并且其余地支有酉\亥
                年干\日干是戊，并且其余地支有丑\未
                年干\日干是己，并且其余地支有子\申
                年干\日干是庚，并且其余地支有丑\未
                年干\日干是辛，并且其余地支有寅\午
                年干\日干是壬，并且其余地支有卯\巳
                年干\日干是癸，并且其余地支有卯\巳
         */
        {
            put("甲丑", "天乙贵人");
            put("甲未", "天乙贵人");
            put("乙子", "天乙贵人");
            put("乙申", "天乙贵人");
            put("丙酉", "天乙贵人");
            put("丙亥", "天乙贵人");
            put("丁酉", "天乙贵人");
            put("丁亥", "天乙贵人");
            put("戊丑", "天乙贵人");
            put("戊未", "天乙贵人");
            put("己子", "天乙贵人");
            put("己申", "天乙贵人");
            put("庚丑", "天乙贵人");
            put("庚未", "天乙贵人");
            put("辛寅", "天乙贵人");
            put("辛午", "天乙贵人");
            put("壬卯", "天乙贵人");
            put("壬巳", "天乙贵人");
            put("癸卯", "天乙贵人");
            put("癸巳", "天乙贵人");
        }
    };

    /**
     * 福星贵人（年干\日干+其余地支为键）
     */
    public static final Map<String, String> FU_XING_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'子\寅'。乙见'丑\卯'。丙见'子\寅'。丁见'亥'。戊见'申'。己见'未'。庚见'午'。辛见'巳'。壬见'辰'。癸见'丑\卯'

            二、详解：
                年干\日干是甲，并且其余地支有子\寅
                年干\日干是乙，并且其余地支有丑\卯
                年干\日干是丙，并且其余地支有子\寅
                年干\日干是丁，并且其余地支有亥
                年干\日干是戊，并且其余地支有申
                年干\日干是己，并且其余地支有未
                年干\日干是庚，并且其余地支有午
                年干\日干是辛，并且其余地支有巳
                年干\日干是壬，并且其余地支有辰
                年干\日干是癸，并且其余地支有丑\卯
         */
        {
            put("甲子", "福星贵人");
            put("甲寅", "福星贵人");
            put("乙丑", "福星贵人");
            put("乙卯", "福星贵人");
            put("丙子", "福星贵人");
            put("丙寅", "福星贵人");
            put("丁亥", "福星贵人");
            put("戊申", "福星贵人");
            put("己未", "福星贵人");
            put("庚午", "福星贵人");
            put("辛巳", "福星贵人");
            put("壬辰", "福星贵人");
            put("癸丑", "福星贵人");
            put("癸卯", "福星贵人");
        }
    };

    /**
     * 文昌贵人（年干\日干+其余地支为键）
     */
    public static final Map<String, String> WEN_CHANG_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'巳'。乙见'午'。丙见'申'。丁见'酉'。戊见'申'。己见'酉'。庚见'亥'。辛见'子'。壬见'寅'。癸见'卯'

            二、详解：
                年干\日干是甲，并且其余地支有巳
                年干\日干是乙，并且其余地支有午
                年干\日干是丙，并且其余地支有申
                年干\日干是丁，并且其余地支有酉
                年干\日干是戊，并且其余地支有申
                年干\日干是己，并且其余地支有酉
                年干\日干是庚，并且其余地支有亥
                年干\日干是辛，并且其余地支有子
                年干\日干是壬，并且其余地支有寅
                年干\日干是癸，并且其余地支有卯
         */
        {
            put("甲巳", "文昌贵人");
            put("乙午", "文昌贵人");
            put("丙申", "文昌贵人");
            put("丁酉", "文昌贵人");
            put("戊申", "文昌贵人");
            put("己酉", "文昌贵人");
            put("庚亥", "文昌贵人");
            put("辛子", "文昌贵人");
            put("壬寅", "文昌贵人");
            put("癸卯", "文昌贵人");
        }
    };

    /**
     * 天厨贵人（年干\日干+其余地支为键）
     */
    public static final Map<String, String> TIAN_CHU_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'巳'。乙见'午'。丙见'巳'。丁见'午'。戊见'申'。己见'酉'。庚见'亥'。辛见'子'。壬见'寅'。癸见'卯'

            二、详解：
                年干\日干是甲，并且其余地支有巳
                年干\日干是乙，并且其余地支有午
                年干\日干是丙，并且其余地支有巳
                年干\日干是丁，并且其余地支有午
                年干\日干是戊，并且其余地支有申
                年干\日干是己，并且其余地支有酉
                年干\日干是庚，并且其余地支有亥
                年干\日干是辛，并且其余地支有子
                年干\日干是壬，并且其余地支有寅
                年干\日干是癸，并且其余地支有卯
         */
        {
            put("甲巳", "天厨贵人");
            put("乙午", "天厨贵人");
            put("丙巳", "天厨贵人");
            put("丁午", "天厨贵人");
            put("戊申", "天厨贵人");
            put("己酉", "天厨贵人");
            put("庚亥", "天厨贵人");
            put("辛子", "天厨贵人");
            put("壬寅", "天厨贵人");
            put("癸卯", "天厨贵人");
        }
    };

    /**
     * 国印（年干\日干+其余地支为键）
     */
    public static final Map<String, String> GUO_YIN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'戌'。乙见'亥'。丙见'丑'。丁见'寅'。戊见'丑'。己见'寅'。庚见'辰'。辛见'巳'。壬见'未'。癸见'申'

            二、详解：
                年干\日干是甲，并且其余地支有戌
                年干\日干是乙，并且其余地支有亥
                年干\日干是丙，并且其余地支有丑
                年干\日干是丁，并且其余地支有寅
                年干\日干是戊，并且其余地支有丑
                年干\日干是己，并且其余地支有寅
                年干\日干是庚，并且其余地支有辰
                年干\日干是辛，并且其余地支有巳
                年干\日干是壬，并且其余地支有未
                年干\日干是癸，并且其余地支有申
         */
        {
            put("甲戌", "国印");
            put("乙亥", "国印");
            put("丙丑", "国印");
            put("丁寅", "国印");
            put("戊丑", "国印");
            put("己寅", "国印");
            put("庚辰", "国印");
            put("辛巳", "国印");
            put("壬未", "国印");
            put("癸申", "国印");
        }
    };

    /**
     * 金舆（年干\日干+其余地支为键）
     */
    public static final Map<String, String> JIN_YU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余地支】甲见'辰'。乙见'巳'。丙见'未'。丁见'申'。戊见'未'。己见'申'。庚见'戌'。辛见'亥'。壬见'丑'。癸见'寅'

            二、详解：
                年干\日干是甲，并且其余地支有辰
                年干\日干是乙，并且其余地支有巳
                年干\日干是丙，并且其余地支有未
                年干\日干是丁，并且其余地支有申
                年干\日干是戊，并且其余地支有未
                年干\日干是己，并且其余地支有申
                年干\日干是庚，并且其余地支有戌
                年干\日干是辛，并且其余地支有亥
                年干\日干是壬，并且其余地支有丑
                年干\日干是癸，并且其余地支有寅
         */
        {
            put("甲辰", "金舆");
            put("乙巳", "金舆");
            put("丙未", "金舆");
            put("丁申", "金舆");
            put("戊未", "金舆");
            put("己申", "金舆");
            put("庚戌", "金舆");
            put("辛亥", "金舆");
            put("壬丑", "金舆");
            put("癸寅", "金舆");
        }
    };

    /**
     * 红艳煞（日干+其余地支为键）
     */
    public static final Map<String, String> HONG_YAN_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查其余地支】甲见'午'。乙见'申'。丙见'寅'。丁见'未'。戊见'辰'。己见'辰'。庚见'戌'。辛见'酉'。壬见'子'。癸见'申'

            二、详解：
                日干是甲，并且其余地支有午
                日干是乙，并且其余地支有申
                日干是丙，并且其余地支有寅
                日干是丁，并且其余地支有未
                日干是戊，并且其余地支有辰
                日干是己，并且其余地支有辰
                日干是庚，并且其余地支有戌
                日干是辛，并且其余地支有酉
                日干是壬，并且其余地支有子
                日干是癸，并且其余地支有申
         */
        {
            put("甲午", "红艳煞");
            put("乙申", "红艳煞");
            put("丙寅", "红艳煞");
            put("丁未", "红艳煞");
            put("戊辰", "红艳煞");
            put("己辰", "红艳煞");
            put("庚戌", "红艳煞");
            put("辛酉", "红艳煞");
            put("壬子", "红艳煞");
            put("癸申", "红艳煞");
        }
    };

    /**
     * 羊刃（日干+其余地支为键）
     */
    public static final Map<String, String> YANG_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查其余地支】甲见'卯'。乙见'寅'。丙见'午'。丁见'巳'。戊见'午'。己见'巳'。庚见'酉'。辛见'申'。壬见'子'。癸见'亥'

            二、详解：
                日干是甲，并且其余地支有卯
                日干是乙，并且其余地支有寅
                日干是丙，并且其余地支有午
                日干是丁，并且其余地支有巳
                日干是戊，并且其余地支有午
                日干是己，并且其余地支有巳
                日干是庚，并且其余地支有酉
                日干是辛，并且其余地支有申
                日干是壬，并且其余地支有子
                日干是癸，并且其余地支有亥
         */
        {
            put("甲卯", "羊刃");
            put("乙寅", "羊刃");
            put("丙午", "羊刃");
            put("丁巳", "羊刃");
            put("戊午", "羊刃");
            put("己巳", "羊刃");
            put("庚酉", "羊刃");
            put("辛申", "羊刃");
            put("壬子", "羊刃");
            put("癸亥", "羊刃");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 飞刃（日干+其余地支为键）
     */
    public static final Map<String, String> FEI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查其余地支】甲见'酉'。乙见'申'。丙见'子'。丁见'亥'。戊见'子'。己见'亥'。庚见'卯'。辛见'寅'。壬见'午'。癸见'巳'

            二、详解：
                日干是甲，并且其余地支有酉
                日干是乙，并且其余地支有申
                日干是丙，并且其余地支有子
                日干是丁，并且其余地支有亥
                日干是戊，并且其余地支有子
                日干是己，并且其余地支有亥
                日干是庚，并且其余地支有卯
                日干是辛，并且其余地支有寅
                日干是壬，并且其余地支有午
                日干是癸，并且其余地支有巳
         */
        {
            put("甲酉", "飞刃");
            put("乙申", "飞刃");
            put("丙子", "飞刃");
            put("丁亥", "飞刃");
            put("戊子", "飞刃");
            put("己亥", "飞刃");
            put("庚卯", "飞刃");
            put("辛寅", "飞刃");
            put("壬午", "飞刃");
            put("癸巳", "飞刃");
        }
    };

    /**
     * 流霞（日干+其余地支为键）
     */
    public static final Map<String, String> LIU_XIA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查其余地支】甲见'酉'。乙见'戌'。丙见'未'。丁见'申'。戊见'巳'。己见'午'。庚见'辰'。辛见'卯'。壬见'亥'。癸见'寅'

            二、详解：
                日干是甲，并且其余地支有酉
                日干是乙，并且其余地支有戌
                日干是丙，并且其余地支有未
                日干是丁，并且其余地支有申
                日干是戊，并且其余地支有巳
                日干是己，并且其余地支有午
                日干是庚，并且其余地支有辰
                日干是辛，并且其余地支有卯
                日干是壬，并且其余地支有亥
                日干是癸，并且其余地支有寅
         */
        {
            put("甲酉", "流霞");
            put("乙戌", "流霞");
            put("丙未", "流霞");
            put("丁申", "流霞");
            put("戊巳", "流霞");
            put("己午", "流霞");
            put("庚辰", "流霞");
            put("辛卯", "流霞");
            put("壬亥", "流霞");
            put("癸寅", "流霞");
        }
    };

    /**
     * 禄神（日干+其余地支为键）
     */
    public static final Map<String, String> LU_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查其余地支】甲见'寅'。乙见'卯'。丙见'巳'。丁见'午'。戊见'巳'。己见'午'。庚见'申'。辛见'酉'。壬见'亥'。癸见'子'

            二、详解：
                日干是甲，并且其余地支有寅
                日干是乙，并且其余地支有卯
                日干是丙，并且其余地支有巳
                日干是丁，并且其余地支有午
                日干是戊，并且其余地支有巳
                日干是己，并且其余地支有午
                日干是庚，并且其余地支有申
                日干是辛，并且其余地支有酉
                日干是壬，并且其余地支有亥
                日干是癸，并且其余地支有子
         */
        {
            put("甲寅", "禄神");
            put("乙卯", "禄神");
            put("丙巳", "禄神");
            put("丁午", "禄神");
            put("戊巳", "禄神");
            put("己午", "禄神");
            put("庚申", "禄神");
            put("辛酉", "禄神");
            put("壬亥", "禄神");
            put("癸子", "禄神");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 驿马（年支\日支+其余地支为键）
     */
    public static final Map<String, String> YI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'寅'。丑见'亥'。寅见'申'。卯见'巳'。辰见'寅'。巳见'亥'。午见'申'。未见'巳'。申见'寅'。酉见'亥'。戌见'申'。亥见'巳'

            二、详解：
                年支\日支是子，并且其余地支有寅
                年支\日支是丑，并且其余地支有亥
                年支\日支是寅，并且其余地支有申
                年支\日支是卯，并且其余地支有巳
                年支\日支是辰，并且其余地支有寅
                年支\日支是巳，并且其余地支有亥
                年支\日支是午，并且其余地支有申
                年支\日支是未，并且其余地支有巳
                年支\日支是申，并且其余地支有寅
                年支\日支是酉，并且其余地支有亥
                年支\日支是戌，并且其余地支有申
                年支\日支是亥，并且其余地支有巳
         */
        {
            put("子寅", "驿马");
            put("丑亥", "驿马");
            put("寅申", "驿马");
            put("卯巳", "驿马");
            put("辰寅", "驿马");
            put("巳亥", "驿马");
            put("午申", "驿马");
            put("未巳", "驿马");
            put("申寅", "驿马");
            put("酉亥", "驿马");
            put("戌申", "驿马");
            put("亥巳", "驿马");
        }
    };

    /**
     * 劫煞（年支\日支+其余地支为键）
     */
    public static final Map<String, String> JIE_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'巳'。丑见'寅'。寅见'亥'。卯见'申'。辰见'巳'。巳见'寅'。午见'亥'。未见'申'。申见'巳'。酉见'寅'。戌见'亥'。亥见'申'

            二、详解：
                年支\日支是子，并且其余地支有巳
                年支\日支是丑，并且其余地支有寅
                年支\日支是寅，并且其余地支有亥
                年支\日支是卯，并且其余地支有申
                年支\日支是辰，并且其余地支有巳
                年支\日支是巳，并且其余地支有寅
                年支\日支是午，并且其余地支有亥
                年支\日支是未，并且其余地支有申
                年支\日支是申，并且其余地支有巳
                年支\日支是酉，并且其余地支有寅
                年支\日支是戌，并且其余地支有亥
                年支\日支是亥，并且其余地支有申
         */
        {
            put("子巳", "劫煞");
            put("丑寅", "劫煞");
            put("寅亥", "劫煞");
            put("卯申", "劫煞");
            put("辰巳", "劫煞");
            put("巳寅", "劫煞");
            put("午亥", "劫煞");
            put("未申", "劫煞");
            put("申巳", "劫煞");
            put("酉寅", "劫煞");
            put("戌亥", "劫煞");
            put("亥申", "劫煞");
        }
    };

    /**
     * 将星（年支\日支+其余地支为键）
     */
    public static final Map<String, String> JIANG_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'子'。丑见'酉'。寅见'午'。卯见'卯'。辰见'子'。巳见'酉'。午见'午'。未见'卯'。申见'子'。酉见'酉'。戌见'午'。亥见'卯'

            二、详解：
                年支\日支是子，并且其余地支有子
                年支\日支是丑，并且其余地支有酉
                年支\日支是寅，并且其余地支有午
                年支\日支是卯，并且其余地支有卯
                年支\日支是辰，并且其余地支有子
                年支\日支是巳，并且其余地支有酉
                年支\日支是午，并且其余地支有午
                年支\日支是未，并且其余地支有卯
                年支\日支是申，并且其余地支有子
                年支\日支是酉，并且其余地支有酉
                年支\日支是戌，并且其余地支有午
                年支\日支是亥，并且其余地支有卯
         */
        {
            put("子子", "将星");
            put("丑酉", "将星");
            put("寅午", "将星");
            put("卯卯", "将星");
            put("辰子", "将星");
            put("巳酉", "将星");
            put("午午", "将星");
            put("未卯", "将星");
            put("申子", "将星");
            put("酉酉", "将星");
            put("戌午", "将星");
            put("亥卯", "将星");
        }
    };

    /**
     * 桃花（年支\日支+其余地支为键）
     */
    public static final Map<String, String> TAO_HUA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'酉'。丑见'午'。寅见'卯'。卯见'子'。辰见'酉'。巳见'午'。午见'卯'。未见'子'。申见'酉'。酉见'午'。戌见'卯'。亥见'子'

            二、详解：
                年支\日支是子，并且其余地支有酉
                年支\日支是丑，并且其余地支有午
                年支\日支是寅，并且其余地支有卯
                年支\日支是卯，并且其余地支有子
                年支\日支是辰，并且其余地支有酉
                年支\日支是巳，并且其余地支有午
                年支\日支是午，并且其余地支有卯
                年支\日支是未，并且其余地支有子
                年支\日支是申，并且其余地支有酉
                年支\日支是酉，并且其余地支有午
                年支\日支是戌，并且其余地支有卯
                年支\日支是亥，并且其余地支有子
         */
        {
            put("子酉", "桃花");
            put("丑午", "桃花");
            put("寅卯", "桃花");
            put("卯子", "桃花");
            put("辰酉", "桃花");
            put("巳午", "桃花");
            put("午卯", "桃花");
            put("未子", "桃花");
            put("申酉", "桃花");
            put("酉午", "桃花");
            put("戌卯", "桃花");
            put("亥子", "桃花");
        }
    };

    /**
     * 亡神（年支\日支+其余地支为键）
     */
    public static final Map<String, String> WANG_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'亥'。丑见'申'。寅见'巳'。卯见'寅'。辰见'亥'。巳见'申'。午见'巳'。未见'寅'。申见'亥'。酉见'申'。戌见'巳'。亥见'寅'

            二、详解：
                年支\日支是子，并且其余地支有亥
                年支\日支是丑，并且其余地支有申
                年支\日支是寅，并且其余地支有巳
                年支\日支是卯，并且其余地支有寅
                年支\日支是辰，并且其余地支有亥
                年支\日支是巳，并且其余地支有申
                年支\日支是午，并且其余地支有巳
                年支\日支是未，并且其余地支有寅
                年支\日支是申，并且其余地支有亥
                年支\日支是酉，并且其余地支有申
                年支\日支是戌，并且其余地支有巳
                年支\日支是亥，并且其余地支有寅
         */
        {
            put("子亥", "亡神");
            put("丑申", "亡神");
            put("寅巳", "亡神");
            put("卯寅", "亡神");
            put("辰亥", "亡神");
            put("巳申", "亡神");
            put("午巳", "亡神");
            put("未寅", "亡神");
            put("申亥", "亡神");
            put("酉申", "亡神");
            put("戌巳", "亡神");
            put("亥寅", "亡神");
        }
    };

    /**
     * 吊客（年支+其余地支为键）
     */
    public static final Map<String, String> DIAO_KE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'戌'。丑见'亥'。寅见'子'。卯见'丑'。辰见'寅'。巳见'卯'。午见'辰'。未见'巳'。申见'午'。酉见'未'。戌见'申'。亥见'酉'

            二、详解：
                年支是子，并且其余地支有戌
                年支是丑，并且其余地支有亥
                年支是寅，并且其余地支有子
                年支是卯，并且其余地支有丑
                年支是辰，并且其余地支有寅
                年支是巳，并且其余地支有卯
                年支是午，并且其余地支有辰
                年支是未，并且其余地支有巳
                年支是申，并且其余地支有午
                年支是酉，并且其余地支有未
                年支是戌，并且其余地支有申
                年支是亥，并且其余地支有酉
         */
        {
            put("子戌", "吊客");
            put("丑亥", "吊客");
            put("寅子", "吊客");
            put("卯丑", "吊客");
            put("辰寅", "吊客");
            put("巳卯", "吊客");
            put("午辰", "吊客");
            put("未巳", "吊客");
            put("申午", "吊客");
            put("酉未", "吊客");
            put("戌申", "吊客");
            put("亥酉", "吊客");
        }
    };

    /**
     * 披麻（年支+其余地支为键）
     */
    public static final Map<String, String> PI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'酉'。丑见'戌'。寅见'亥'。卯见'子'。辰见'丑'。巳见'寅'。午见'卯'。未见'辰'。申见'巳'。酉见'午'。戌见'未'。亥见'申'

            二、详解：
                年支是子，并且其余地支有酉
                年支是丑，并且其余地支有戌
                年支是寅，并且其余地支有亥
                年支是卯，并且其余地支有子
                年支是辰，并且其余地支有丑
                年支是巳，并且其余地支有寅
                年支是午，并且其余地支有卯
                年支是未，并且其余地支有辰
                年支是申，并且其余地支有巳
                年支是酉，并且其余地支有午
                年支是戌，并且其余地支有未
                年支是亥，并且其余地支有申
         */
        {
            put("子酉", "披麻");
            put("丑戌", "披麻");
            put("寅亥", "披麻");
            put("卯子", "披麻");
            put("辰丑", "披麻");
            put("巳寅", "披麻");
            put("午卯", "披麻");
            put("未辰", "披麻");
            put("申巳", "披麻");
            put("酉午", "披麻");
            put("戌未", "披麻");
            put("亥申", "披麻");
        }
    };

    /**
     * 天官贵人（年干+其余地支为键）
     */
    public static final Map<String, String> TIAN_GUAN_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干查其余地支】甲见'未'。乙见'辰'。丙见'巳'。丁见'酉'。戊见'戌'。己见'卯'。庚见'丑'。辛见'申'。壬见'寅'。癸见'午'

            二、详解：
                年干是甲，并且其余地支有未
                年干是乙，并且其余地支有辰
                年干是丙，并且其余地支有巳
                年干是丁，并且其余地支有酉
                年干是戊，并且其余地支有戌
                年干是己，并且其余地支有卯
                年干是庚，并且其余地支有丑
                年干是辛，并且其余地支有申
                年干是壬，并且其余地支有寅
                年干是癸，并且其余地支有午
         */
        {
            put("甲未", "天官贵人");
            put("乙辰", "天官贵人");
            put("丙巳", "天官贵人");
            put("丁酉", "天官贵人");
            put("戊戌", "天官贵人");
            put("己卯", "天官贵人");
            put("庚丑", "天官贵人");
            put("辛申", "天官贵人");
            put("壬寅", "天官贵人");
            put("癸午", "天官贵人");
        }
    };

    /**
     * 天喜（年支+其余地支为键）
     */
    public static final Map<String, String> TIAN_XI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'酉'。丑见'申'。寅见'未'。卯见'午'。辰见'巳'。巳见'辰'。午见'卯'。未见'寅'。申见'丑'。酉见'子'。戌见'亥'。亥见'戌'

            二、详解：
                年支是子，并且其余地支有酉
                年支是丑，并且其余地支有申
                年支是寅，并且其余地支有未
                年支是卯，并且其余地支有午
                年支是辰，并且其余地支有巳
                年支是巳，并且其余地支有辰
                年支是午，并且其余地支有卯
                年支是未，并且其余地支有寅
                年支是申，并且其余地支有丑
                年支是酉，并且其余地支有子
                年支是戌，并且其余地支有亥
                年支是亥，并且其余地支有戌
         */
        {
            put("子酉", "天喜");
            put("丑申", "天喜");
            put("寅未", "天喜");
            put("卯午", "天喜");
            put("辰巳", "天喜");
            put("巳辰", "天喜");
            put("午卯", "天喜");
            put("未寅", "天喜");
            put("申丑", "天喜");
            put("酉子", "天喜");
            put("戌亥", "天喜");
            put("亥戌", "天喜");
        }
    };

    /**
     * 勾绞煞（年支+其余地支为键）
     */
    public static final Map<String, String> GOU_JIAO_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'卯'。丑见'辰'。寅见'巳'。卯见'午'。辰见'未'。巳见'申'。午见'酉'。未见'戌'。申见'亥'。酉见'子'。戌见'丑'。亥见'寅'

            二、详解：
                年支是子，并且其余地支有卯
                年支是丑，并且其余地支有辰
                年支是寅，并且其余地支有巳
                年支是卯，并且其余地支有午
                年支是辰，并且其余地支有未
                年支是巳，并且其余地支有申
                年支是午，并且其余地支有酉
                年支是未，并且其余地支有戌
                年支是申，并且其余地支有亥
                年支是酉，并且其余地支有子
                年支是戌，并且其余地支有丑
                年支是亥，并且其余地支有寅
         */
        {
            put("子卯", "勾绞煞");
            put("丑辰", "勾绞煞");
            put("寅巳", "勾绞煞");
            put("卯午", "勾绞煞");
            put("辰未", "勾绞煞");
            put("巳申", "勾绞煞");
            put("午酉", "勾绞煞");
            put("未戌", "勾绞煞");
            put("申亥", "勾绞煞");
            put("酉子", "勾绞煞");
            put("戌丑", "勾绞煞");
            put("亥寅", "勾绞煞");
        }
    };

    /**
     * 红鸾（年支+其余地支为键）
     */
    public static final Map<String, String> HONG_LUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'卯'。丑见'寅'。寅见'丑'。卯见'子'。辰见'亥'。巳见'戌'。午见'酉'。未见'申'。申见'未'。酉见'午'。戌见'巳'。亥见'辰'

            二、详解：
                年支是子，并且其余地支有卯
                年支是丑，并且其余地支有寅
                年支是寅，并且其余地支有丑
                年支是卯，并且其余地支有子
                年支是辰，并且其余地支有亥
                年支是巳，并且其余地支有戌
                年支是午，并且其余地支有酉
                年支是未，并且其余地支有申
                年支是申，并且其余地支有未
                年支是酉，并且其余地支有午
                年支是戌，并且其余地支有巳
                年支是亥，并且其余地支有辰
         */
        {
            put("子卯", "红鸾");
            put("丑寅", "红鸾");
            put("寅丑", "红鸾");
            put("卯子", "红鸾");
            put("辰亥", "红鸾");
            put("巳戌", "红鸾");
            put("午酉", "红鸾");
            put("未申", "红鸾");
            put("申未", "红鸾");
            put("酉午", "红鸾");
            put("戌巳", "红鸾");
            put("亥辰", "红鸾");
        }
    };

    /**
     * 丧门（年支+其余地支为键）
     */
    public static final Map<String, String> SANG_MEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'寅'。丑见'卯'。寅见'辰'。卯见'巳'。辰见'午'。巳见'未'。午见'申'。未见'酉'。申见'戌'。酉见'寅'。戌见'卯'。亥见'辰'

            二、详解：
                年支是子，并且其余地支有寅
                年支是丑，并且其余地支有卯
                年支是寅，并且其余地支有辰
                年支是卯，并且其余地支有巳
                年支是辰，并且其余地支有午
                年支是巳，并且其余地支有未
                年支是午，并且其余地支有申
                年支是未，并且其余地支有酉
                年支是申，并且其余地支有戌
                年支是酉，并且其余地支有亥
                年支是戌，并且其余地支有子
                年支是亥，并且其余地支有丑
         */
        {
            put("子寅", "丧门");
            put("丑卯", "丧门");
            put("寅辰", "丧门");
            put("卯巳", "丧门");
            put("辰午", "丧门");
            put("巳未", "丧门");
            put("午申", "丧门");
            put("未酉", "丧门");
            put("申戌", "丧门");
            put("酉亥", "丧门");
            put("戌子", "丧门");
            put("亥丑", "丧门");
        }
    };

    /**
     * 灾煞（年支+其余地支为键）
     */
    public static final Map<String, String> ZAI_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'午'。丑见'卯'。寅见'子'。卯见'酉'。辰见'午'。巳见'卯'。午见'子'。未见'酉'。申见'午'。酉见'卯'。戌见'子'。亥见'酉'

            二、详解：
                年支是子，并且其余地支有午
                年支是丑，并且其余地支有卯
                年支是寅，并且其余地支有子
                年支是卯，并且其余地支有酉
                年支是辰，并且其余地支有午
                年支是巳，并且其余地支有卯
                年支是午，并且其余地支有子
                年支是未，并且其余地支有酉
                年支是申，并且其余地支有午
                年支是酉，并且其余地支有卯
                年支是戌，并且其余地支有子
                年支是亥，并且其余地支有酉
         */
        {
            put("子午", "灾煞");
            put("丑卯", "灾煞");
            put("寅子", "灾煞");
            put("卯酉", "灾煞");
            put("辰午", "灾煞");
            put("巳卯", "灾煞");
            put("午子", "灾煞");
            put("未酉", "灾煞");
            put("申午", "灾煞");
            put("酉卯", "灾煞");
            put("戌子", "灾煞");
            put("亥酉", "灾煞");
        }
    };

    /**
     * 孤辰（年支+其余地支为键）
     */
    public static final Map<String, String> GU_CHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'寅'。丑见'寅'。寅见'巳'。卯见'巳'。辰见'巳'。巳见'申'。午见'申'。未见'申'。申见'亥'。酉见'亥'。戌见'亥'。亥见'寅'

            二、详解：
                年支是子，并且其余地支有寅
                年支是丑，并且其余地支有寅
                年支是寅，并且其余地支有巳
                年支是卯，并且其余地支有巳
                年支是辰，并且其余地支有巳
                年支是巳，并且其余地支有申
                年支是午，并且其余地支有申
                年支是未，并且其余地支有申
                年支是申，并且其余地支有亥
                年支是酉，并且其余地支有亥
                年支是戌，并且其余地支有亥
                年支是亥，并且其余地支有寅
         */
        {
            put("子寅", "孤辰");
            put("丑寅", "孤辰");
            put("寅巳", "孤辰");
            put("卯巳", "孤辰");
            put("辰巳", "孤辰");
            put("巳申", "孤辰");
            put("午申", "孤辰");
            put("未申", "孤辰");
            put("申亥", "孤辰");
            put("酉亥", "孤辰");
            put("戌亥", "孤辰");
            put("亥寅", "孤辰");
        }
    };

    /**
     * 寡宿（年支+其余地支为键）
     */
    public static final Map<String, String> GUA_XIU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'戌'。丑见'戌'。寅见'丑'。卯见'丑'。辰见'丑'。巳见'辰'。午见'辰'。未见'辰'。申见'未'。酉见'未'。戌见'未'。亥见'戌'

            二、详解：
                年支是子，并且其余地支有戌
                年支是丑，并且其余地支有戌
                年支是寅，并且其余地支有丑
                年支是卯，并且其余地支有丑
                年支是辰，并且其余地支有丑
                年支是巳，并且其余地支有辰
                年支是午，并且其余地支有辰
                年支是未，并且其余地支有辰
                年支是申，并且其余地支有未
                年支是酉，并且其余地支有未
                年支是戌，并且其余地支有未
                年支是亥，并且其余地支有戌
         */
        {
            put("子戌", "寡宿");
            put("丑戌", "寡宿");
            put("寅丑", "寡宿");
            put("卯丑", "寡宿");
            put("辰丑", "寡宿");
            put("巳辰", "寡宿");
            put("午辰", "寡宿");
            put("未辰", "寡宿");
            put("申未", "寡宿");
            put("酉未", "寡宿");
            put("戌未", "寡宿");
            put("亥戌", "寡宿");
        }
    };

    /**
     * 元辰（年支+其余地支），阳男阴女
     */
    public static final Map<String, String> YUAN_CHEN_YANG_NAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'未'。丑见'申'。寅见'酉'。卯见'戌'。辰见'亥'。巳见'子'。午见'丑'。未见'寅'。申见'卯'。酉见'辰'。戌见'巳'。亥见'午'

            二、详解：
                年支是子，并且其余地支有未
                年支是丑，并且其余地支有申
                年支是寅，并且其余地支有酉
                年支是卯，并且其余地支有戌
                年支是辰，并且其余地支有亥
                年支是巳，并且其余地支有子
                年支是午，并且其余地支有丑
                年支是未，并且其余地支有寅
                年支是申，并且其余地支有卯
                年支是酉，并且其余地支有辰
                年支是戌，并且其余地支有巳
                年支是亥，并且其余地支有午
         */
        {
            put("子未", "元辰");
            put("丑申", "元辰");
            put("寅酉", "元辰");
            put("卯戌", "元辰");
            put("辰亥", "元辰");
            put("巳子", "元辰");
            put("午丑", "元辰");
            put("未寅", "元辰");
            put("申卯", "元辰");
            put("酉辰", "元辰");
            put("戌巳", "元辰");
            put("亥午", "元辰");
        }
    };

    /**
     * 元辰（年支+其余地支），阴男阳女
     */
    public static final Map<String, String> YUAN_CHEN_YIN_NAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'巳'。丑见'午'。寅见'未'。卯见'申'。辰见'酉'。巳见'戌'。午见'亥'。未见'子'。申见'丑'。酉见'寅'。戌见'卯'。亥见'辰'

            二、详解：
                年支是子，并且其余地支有巳
                年支是丑，并且其余地支有午
                年支是寅，并且其余地支有未
                年支是卯，并且其余地支有申
                年支是辰，并且其余地支有酉
                年支是巳，并且其余地支有戌
                年支是午，并且其余地支有亥
                年支是未，并且其余地支有子
                年支是申，并且其余地支有丑
                年支是酉，并且其余地支有寅
                年支是戌，并且其余地支有卯
                年支是亥，并且其余地支有辰
         */
        {
            put("子巳", "元辰");
            put("丑午", "元辰");
            put("寅未", "元辰");
            put("卯申", "元辰");
            put("辰酉", "元辰");
            put("巳戌", "元辰");
            put("午亥", "元辰");
            put("未子", "元辰");
            put("申丑", "元辰");
            put("酉寅", "元辰");
            put("戌卯", "元辰");
            put("亥辰", "元辰");
        }
    };

    /**
     * 血刃（月支+其余地支为键）
     */
    public static final Map<String, String> XUE_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余地支】子见'午'。丑见'子'。寅见'丑'。卯见'未'。辰见'寅'。巳见'申'。午见'卯'。未见'酉'。申见'辰'。酉见'戌'。戌见'巳'。亥见'亥'

            二、详解：
                月支是子，并且其余地支有午
                月支是丑，并且其余地支有子
                月支是寅，并且其余地支有丑
                月支是卯，并且其余地支有未
                月支是辰，并且其余地支有寅
                月支是巳，并且其余地支有申
                月支是午，并且其余地支有卯
                月支是未，并且其余地支有酉
                月支是申，并且其余地支有辰
                月支是酉，并且其余地支有戌
                月支是戌，并且其余地支有巳
                月支是亥，并且其余地支有亥
         */
        {
            put("子午", "血刃");
            put("丑子", "血刃");
            put("寅丑", "血刃");
            put("卯未", "血刃");
            put("辰寅", "血刃");
            put("巳申", "血刃");
            put("午卯", "血刃");
            put("未酉", "血刃");
            put("申辰", "血刃");
            put("酉戌", "血刃");
            put("戌巳", "血刃");
            put("亥亥", "血刃");
        }
    };

    /**
     * 天医（月支+其余地支为键）
     */
    public static final Map<String, String> TIAN_YI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余地支】子见'亥'。丑见'子'。寅见'丑'。卯见'寅'。辰见'卯'。巳见'辰'。午见'巳'。未见'午'。申见'未'。酉见'申'。戌见'酉'。亥见'戌'

            二、详解：
                月支是子，并且其余地支有亥
                月支是丑，并且其余地支有子
                月支是寅，并且其余地支有丑
                月支是卯，并且其余地支有寅
                月支是辰，并且其余地支有卯
                月支是巳，并且其余地支有辰
                月支是午，并且其余地支有巳
                月支是未，并且其余地支有午
                月支是申，并且其余地支有未
                月支是酉，并且其余地支有申
                月支是戌，并且其余地支有酉
                月支是亥，并且其余地支有戌
         */
        {
            put("子亥", "天医");
            put("丑子", "天医");
            put("寅丑", "天医");
            put("卯寅", "天医");
            put("辰卯", "天医");
            put("巳辰", "天医");
            put("午巳", "天医");
            put("未午", "天医");
            put("申未", "天医");
            put("酉申", "天医");
            put("戌酉", "天医");
            put("亥戌", "天医");
        }
    };

    /**
     * 天德合（月支+其余天干或地支为键）
     */
    public static final Map<String, String> TIAN_DE_HE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余天干或地支】子见'申'。丑见'乙'。寅见'壬'。卯见'巳'。辰见'丁'。巳见'丙'。午见'寅'。未见'己'。申见'戊'。酉见'亥'。戌见'辛'。亥见'庚'

            二、详解：
                月支是子，并且其余地支有申
                月支是丑，并且其余天干有乙
                月支是寅，并且其余天干有壬
                月支是卯，并且其余地支有巳
                月支是辰，并且其余天干有丁
                月支是巳，并且其余天干有丙
                月支是午，并且其余地支有寅
                月支是未，并且其余天干有己
                月支是申，并且其余天干有戊
                月支是酉，并且其余地支有亥
                月支是戌，并且其余天干有辛
                月支是亥，并且其余天干有庚
         */
        {
            put("子申", "天德合");
            put("丑乙", "天德合");
            put("寅壬", "天德合");
            put("卯巳", "天德合");
            put("辰丁", "天德合");
            put("巳丙", "天德合");
            put("午寅", "天德合");
            put("未己", "天德合");
            put("申戊", "天德合");
            put("酉亥", "天德合");
            put("戌辛", "天德合");
            put("亥庚", "天德合");
        }
    };

    /**
     * 词馆（年柱纳音五行+干支为键），禄命法
     */
    public static final Map<String, String> CI_GUAN_LU_MING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年柱纳音五行查干支】木见'寅'。火见'巳'。土见'亥'。金见'申'。水见'亥'

            二、详解：
                年柱纳音五行是木，并且月支\日支\时支有寅（庚寅为正词馆）
                年柱纳音五行是火，并且月支\日支\时支有巳（乙巳为正词馆）
                年柱纳音五行是土，并且月支\日支\时支有亥（丁亥为正词馆）
                年柱纳音五行是金，并且月支\日支\时支有申（壬申为正词馆）
                年柱纳音五行是水，并且月支\日支\时支有亥（癸亥为正词馆）
         */
        {
            put("木寅", "词馆");
            put("火巳", "词馆");
            put("土亥", "词馆");
            put("金申", "词馆");
            put("水亥", "词馆");

            put("木庚寅", "正词馆");
            put("火乙巳", "正词馆");
            put("土丁亥", "正词馆");
            put("金壬申", "正词馆");
            put("水癸亥", "正词馆");
        }
    };

    /**
     * 词馆（年干\日干+其余天干或地支为键），子平法
     */
    public static final Map<String, String> CI_GUAN_ZI_PING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余天干或地支】甲见'己\亥'。乙见'壬\午'。丙见'丙\寅'。丁见'丁\酉'。戊见'戊\寅'。己见'己\酉'。庚见'辛\巳'。辛见'甲\子'。壬见'甲\申'。癸见'乙\卯'

            二、详解：
                年干\日干是甲，并且其余天干或地支有己\亥
                年干\日干是乙，并且其余天干或地支有壬\午
                年干\日干是丙，并且其余天干或地支有丙\寅
                年干\日干是丁，并且其余天干或地支有丁\酉
                年干\日干是戊，并且其余天干或地支有戊\寅
                年干\日干是己，并且其余天干或地支有己\酉
                年干\日干是庚，并且其余天干或地支有辛\巳
                年干\日干是辛，并且其余天干或地支有甲\子
                年干\日干是壬，并且其余天干或地支有甲\申
                年干\日干是癸，并且其余天干或地支有乙\卯
         */
        {
            put("甲己", "词馆");
            put("甲亥", "词馆");
            put("乙壬", "词馆");
            put("乙午", "词馆");
            put("丙丙", "词馆");
            put("丙寅", "词馆");
            put("丁丁", "词馆");
            put("丁酉", "词馆");
            put("戊戊", "词馆");
            put("戊寅", "词馆");
            put("己己", "词馆");
            put("己酉", "词馆");
            put("庚辛", "词馆");
            put("庚巳", "词馆");
            put("辛甲", "词馆");
            put("辛子", "词馆");
            put("壬甲", "词馆");
            put("壬申", "词馆");
            put("癸乙", "词馆");
            put("癸卯", "词馆");
        }
    };

    /**
     * 学堂（年柱纳音五行+干支为键），禄命法
     */
    public static final Map<String, String> XUE_TANG_LU_MING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年柱纳音五行查干支】木见'亥'。火见'寅'。土见'申'。金见'巳'。水见'申'

            二、详解：
                年柱纳音五行是木，并且月支\日支\时支有亥（己亥为正学堂）
                年柱纳音五行是火，并且月支\日支\时支有寅（丙寅为正学堂）
                年柱纳音五行是土，并且月支\日支\时支有申（戊申为正学堂）
                年柱纳音五行是金，并且月支\日支\时支有巳（辛巳为正学堂）
                年柱纳音五行是水，并且月支\日支\时支有申（甲申为正学堂）
         */
        {
            put("木亥", "学堂");
            put("火寅", "学堂");
            put("土申", "学堂");
            put("金巳", "学堂");
            put("水申", "学堂");

            put("木己亥", "正学堂");
            put("火丙寅", "正学堂");
            put("土戊申", "正学堂");
            put("金辛巳", "正学堂");
            put("水甲申", "正学堂");
        }
    };

    /**
     * 学堂（年干\日干+其余天干或地支为键），子平法
     */
    public static final Map<String, String> XUE_TANG_ZI_PING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余天干或地支】甲见'己\亥'。乙见'壬\午'。丙见'丙\寅'。丁见'丁\酉'。戊见'戊\寅'。己见'己\酉'。庚见'辛\巳'。辛见'甲\子'。壬见'甲\申'。癸见'乙\卯'

            二、详解：
                年干\日干是甲，并且其余天干或地支有己\亥
                年干\日干是乙，并且其余天干或地支有壬\午
                年干\日干是丙，并且其余天干或地支有丙\寅
                年干\日干是丁，并且其余天干或地支有丁\酉
                年干\日干是戊，并且其余天干或地支有戊\寅
                年干\日干是己，并且其余天干或地支有己\酉
                年干\日干是庚，并且其余天干或地支有辛\巳
                年干\日干是辛，并且其余天干或地支有甲\子
                年干\日干是壬，并且其余天干或地支有甲\申
                年干\日干是癸，并且其余天干或地支有乙\卯
         */
        {
            put("甲己", "学堂");
            put("甲亥", "学堂");
            put("乙壬", "学堂");
            put("乙午", "学堂");
            put("丙丙", "学堂");
            put("丙寅", "学堂");
            put("丁丁", "学堂");
            put("丁酉", "学堂");
            put("戊戊", "学堂");
            put("戊寅", "学堂");
            put("己己", "学堂");
            put("己酉", "学堂");
            put("庚辛", "学堂");
            put("庚巳", "学堂");
            put("辛甲", "学堂");
            put("辛子", "学堂");
            put("壬甲", "学堂");
            put("壬申", "学堂");
            put("癸乙", "学堂");
            put("癸卯", "学堂");
        }
    };

    /**
     * 天赦（月支+日干支为键）
     */
    public static final Map<String, String> TIAN_SHE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'甲子'。丑见'甲子'。寅见'戊寅'。卯见'戊寅'。辰见'戊寅'。巳见'甲午'。午见'甲午'。未见'甲午'。申见'戊申'。酉见'戊申'。戌见'戊申'。亥见'甲子'

            二、详解：
                月支是子，并且日干支有甲子
                月支是丑，并且日干支有甲子
                月支是寅，并且日干支有戊寅
                月支是卯，并且日干支有戊寅
                月支是辰，并且日干支有戊寅
                月支是巳，并且日干支有甲午
                月支是午，并且日干支有甲午
                月支是未，并且日干支有甲午
                月支是申，并且日干支有戊申
                月支是酉，并且日干支有戊申
                月支是戌，并且日干支有戊申
                月支是亥，并且日干支有甲子
         */
        {
            put("子甲子", "天赦");
            put("丑甲子", "天赦");
            put("寅戊寅", "天赦");
            put("卯戊寅", "天赦");
            put("辰戊寅", "天赦");
            put("巳甲午", "天赦");
            put("午甲午", "天赦");
            put("未甲午", "天赦");
            put("申戊申", "天赦");
            put("酉戊申", "天赦");
            put("戌戊申", "天赦");
            put("亥甲子", "天赦");
        }
    };

    /**
     * 天转（月支+日干支为键）
     */
    public static final Map<String, String> TIAN_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'壬子'。丑见'壬子'。寅见'乙卯'。卯见'乙卯'。辰见'乙卯'。巳见'丙午'。午见'丙午'。未见'丙午'。申见'辛酉'。酉见'辛酉'。戌见'辛酉'。亥见'壬子'

            二、详解：
                月支是子，并且日干支有壬子
                月支是丑，并且日干支有壬子
                月支是寅，并且日干支有乙卯
                月支是卯，并且日干支有乙卯
                月支是辰，并且日干支有乙卯
                月支是巳，并且日干支有丙午
                月支是午，并且日干支有丙午
                月支是未，并且日干支有丙午
                月支是申，并且日干支有辛酉
                月支是酉，并且日干支有辛酉
                月支是戌，并且日干支有辛酉
                月支是亥，并且日干支有壬子
         */
        {
            put("子壬子", "天转");
            put("丑壬子", "天转");
            put("寅乙卯", "天转");
            put("卯乙卯", "天转");
            put("辰乙卯", "天转");
            put("巳丙午", "天转");
            put("午丙午", "天转");
            put("未丙午", "天转");
            put("申辛酉", "天转");
            put("酉辛酉", "天转");
            put("戌辛酉", "天转");
            put("亥壬子", "天转");
        }
    };

    /**
     * 地转（月支+日干支为键）
     */
    public static final Map<String, String> DI_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'丙子'。丑见'丙子'。寅见'辛卯'。卯见'辛卯'。辰见'辛卯'。巳见'戊午'。午见'戊午'。未见'戊午'。申见癸酉''。酉见'癸酉'。戌见'癸酉'。亥见'丙子'

            二、详解：
                月支是子，并且日干支有丙子
                月支是丑，并且日干支有丙子
                月支是寅，并且日干支有辛卯
                月支是卯，并且日干支有辛卯
                月支是辰，并且日干支有辛卯
                月支是巳，并且日干支有戊午
                月支是午，并且日干支有戊午
                月支是未，并且日干支有戊午
                月支是申，并且日干支有癸酉
                月支是酉，并且日干支有癸酉
                月支是戌，并且日干支有癸酉
                月支是亥，并且日干支有丙子
         */
        {
            put("子丙子", "地转");
            put("丑丙子", "地转");
            put("寅辛卯", "地转");
            put("卯辛卯", "地转");
            put("辰辛卯", "地转");
            put("巳戊午", "地转");
            put("午戊午", "地转");
            put("未戊午", "地转");
            put("申癸酉", "地转");
            put("酉癸酉", "地转");
            put("戌癸酉", "地转");
            put("亥丙子", "地转");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 月德贵人（月支+其余天干为键）
     */
    public static final Map<String, String> YUE_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余天干】子见'壬'。丑见'庚'。寅见'丙'。卯见'甲'。辰见'壬'。巳见'庚'。午见'丙'。未见'甲'。申见'壬'。酉见'庚'。戌见'丙'。亥见'甲'

            二、详解：
                月支是子，并且其余天干有壬
                月支是丑，并且其余天干有庚
                月支是寅，并且其余天干有丙
                月支是卯，并且其余天干有甲
                月支是辰，并且其余天干有壬
                月支是巳，并且其余天干有庚
                月支是午，并且其余天干有丙
                月支是未，并且其余天干有甲
                月支是申，并且其余天干有壬
                月支是酉，并且其余天干有庚
                月支是戌，并且其余天干有丙
                月支是亥，并且其余天干有甲
         */
        {
            put("子壬", "月德贵人");
            put("丑庚", "月德贵人");
            put("寅丙", "月德贵人");
            put("卯甲", "月德贵人");
            put("辰壬", "月德贵人");
            put("巳庚", "月德贵人");
            put("午丙", "月德贵人");
            put("未甲", "月德贵人");
            put("申壬", "月德贵人");
            put("酉庚", "月德贵人");
            put("戌丙", "月德贵人");
            put("亥甲", "月德贵人");
        }
    };

    /**
     * 德秀贵人（月支+其余天干为键）
     */
    public static final Map<String, String> DE_XIU_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余天干】子见'甲\丙\戊\己\辛\壬\癸'。丑见'乙\庚\辛'。寅见'丙\丁\戊\癸'。卯见'甲\乙\丁\壬'。辰见'甲\丙\戊\己\辛\壬\癸'。巳见'乙\庚\辛'。午见'丙\丁\戊\癸'。未见'甲\乙\丁\壬'。申见'甲\丙\戊\己\辛\壬\癸'。酉见'乙\庚\辛'。戌见'丙\丁\戊\癸'。亥见'甲\乙\丁\壬'

            二、详解：
                月支是子，并且其余天干有甲\丙\戊\己\辛\壬\癸
                月支是丑，并且其余天干有乙\庚\辛
                月支是寅，并且其余天干有丙\丁\戊\癸
                月支是卯，并且其余天干有甲\乙\丁\壬
                月支是辰，并且其余天干有甲\丙\戊\己\辛\壬\癸
                月支是巳，并且其余天干有乙\庚\辛
                月支是午，并且其余天干有丙\丁\戊\癸
                月支是未，并且其余天干有甲\乙\丁\壬
                月支是申，并且其余天干有甲\丙\戊\己\辛\壬\癸
                月支是酉，并且其余天干有乙\庚\辛
                月支是戌，并且其余天干有丙\丁\戊\癸
                月支是亥，并且其余天干有甲\乙\丁\壬
         */
        {
            put("子甲", "德秀贵人");
            put("子丙", "德秀贵人");
            put("子戊", "德秀贵人");
            put("子己", "德秀贵人");
            put("子辛", "德秀贵人");
            put("子壬", "德秀贵人");
            put("子癸", "德秀贵人");
            put("丑乙", "德秀贵人");
            put("丑庚", "德秀贵人");
            put("丑辛", "德秀贵人");
            put("寅丙", "德秀贵人");
            put("寅丁", "德秀贵人");
            put("寅戊", "德秀贵人");
            put("寅癸", "德秀贵人");
            put("卯甲", "德秀贵人");
            put("卯乙", "德秀贵人");
            put("卯丁", "德秀贵人");
            put("卯壬", "德秀贵人");
            put("辰甲", "德秀贵人");
            put("辰丙", "德秀贵人");
            put("辰戊", "德秀贵人");
            put("辰己", "德秀贵人");
            put("辰辛", "德秀贵人");
            put("辰壬", "德秀贵人");
            put("辰癸", "德秀贵人");
            put("巳乙", "德秀贵人");
            put("巳庚", "德秀贵人");
            put("巳辛", "德秀贵人");
            put("午丙", "德秀贵人");
            put("午丁", "德秀贵人");
            put("午戊", "德秀贵人");
            put("午癸", "德秀贵人");
            put("未甲", "德秀贵人");
            put("未乙", "德秀贵人");
            put("未丁", "德秀贵人");
            put("未壬", "德秀贵人");
            put("申甲", "德秀贵人");
            put("申丙", "德秀贵人");
            put("申戊", "德秀贵人");
            put("申己", "德秀贵人");
            put("申辛", "德秀贵人");
            put("申壬", "德秀贵人");
            put("申癸", "德秀贵人");
            put("酉乙", "德秀贵人");
            put("酉庚", "德秀贵人");
            put("酉辛", "德秀贵人");
            put("戌丙", "德秀贵人");
            put("戌丁", "德秀贵人");
            put("戌戊", "德秀贵人");
            put("戌癸", "德秀贵人");
            put("亥甲", "德秀贵人");
            put("亥乙", "德秀贵人");
            put("亥丁", "德秀贵人");
            put("亥壬", "德秀贵人");
        }
    };

    /**
     * 天德贵人（月支+其余天干\其余地支为键）
     */
    public static final Map<String, String> TIAN_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余天干\其余地支】子见'巳'。丑见'庚'。寅见'丁'。卯见'申'。辰见'壬'。巳见'辛'。午见'亥'。未见'甲'。申见'癸'。酉见'寅'。戌见'丙'。亥见'乙'

            二、详解：
                月支是子，并且其余地支有巳
                月支是丑，并且其余天干有庚
                月支是寅，并且其余天干有丁
                月支是卯，并且其余地支有申
                月支是辰，并且其余天干有壬
                月支是巳，并且其余天干有辛
                月支是午，并且其余地支有亥
                月支是未，并且其余天干有甲
                月支是申，并且其余天干有癸
                月支是酉，并且其余地支有寅
                月支是戌，并且其余天干有丙
                月支是亥，并且其余天干有乙
         */
        {
            put("子巳", "天德贵人");
            put("丑庚", "天德贵人");
            put("寅丁", "天德贵人");
            put("卯申", "天德贵人");
            put("辰壬", "天德贵人");
            put("巳辛", "天德贵人");
            put("午亥", "天德贵人");
            put("未甲", "天德贵人");
            put("申癸", "天德贵人");
            put("酉寅", "天德贵人");
            put("戌丙", "天德贵人");
            put("亥乙", "天德贵人");
        }
    };

    /**
     * 月德合（月支+其余天干为键）
     */
    public static final Map<String, String> YUE_DE_HE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余天干】子见'丁'。丑见'乙'。寅见'辛'。卯见'己'。辰见'丁'。巳见'乙'。午见'辛'。未见'己'。申见'丁'。酉见'乙'。戌见'辛'。亥见'己'

            二、详解：
                月支是子，并且其余天干有丁
                月支是丑，并且其余天干有乙
                月支是寅，并且其余天干有辛
                月支是卯，并且其余天干有己
                月支是辰，并且其余天干有丁
                月支是巳，并且其余天干有乙
                月支是午，并且其余天干有辛
                月支是未，并且其余天干有己
                月支是申，并且其余天干有丁
                月支是酉，并且其余天干有乙
                月支是戌，并且其余天干有辛
                月支是亥，并且其余天干有己
         */
        {
            put("子丁", "月德合");
            put("丑乙", "月德合");
            put("寅辛", "月德合");
            put("卯己", "月德合");
            put("辰丁", "月德合");
            put("巳乙", "月德合");
            put("午辛", "月德合");
            put("未己", "月德合");
            put("申丁", "月德合");
            put("酉乙", "月德合");
            put("戌辛", "月德合");
            put("亥己", "月德合");
        }
    };

    /**
     * 拱禄（日干支+时干支+其余地支为键）
     */
    public static final Map<String, String> GONG_LU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干支+时干支查其余地支】日癸亥时癸丑见'子'。日癸丑时癸亥见'子'。日丁巳时丁未见'午'。日己未时己巳见'午'。日戊辰时戊午见'巳'

            二、详解：
                日干支是癸亥，时干支是癸丑，并且其余地支有子
                日干支是癸丑，时干支是癸亥，并且其余地支有子
                日干支是丁巳，时干支是丁未，并且其余地支有午
                日干支是己未，时干支是己巳，并且其余地支有午
                日干支是戊辰，时干支是戊午，并且其余地支有巳
         */
        {
            put("癸亥癸丑子", "拱禄");
            put("癸丑癸亥子", "拱禄");
            put("丁巳丁未午", "拱禄");
            put("己未己巳午", "拱禄");
            put("戊辰戊午巳", "拱禄");
        }
    };

    /**
     * 华盖（年支\日支+其余地支为键）
     */
    public static final Map<String, String> HUA_GAI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'辰'。丑见'丑'。寅见'戌'。卯见'未'。辰见'辰'。巳见'丑'。午见'戌'。未见'未'。申见'辰'。酉见'丑'。戌见'戌'。亥见'未'

            二、详解：
                年支\日支是子，并且其余地支有辰
                年支\日支是丑，并且其余地支有丑
                年支\日支是寅，并且其余地支有戌
                年支\日支是卯，并且其余地支有未
                年支\日支是辰，并且其余地支有辰
                年支\日支是巳，并且其余地支有丑
                年支\日支是午，并且其余地支有戌
                年支\日支是未，并且其余地支有未
                年支\日支是申，并且其余地支有辰
                年支\日支是酉，并且其余地支有丑
                年支\日支是戌，并且其余地支有戌
                年支\日支是亥，并且其余地支有未
         */
        {
            put("子辰", "华盖");
            put("丑丑", "华盖");
            put("寅戌", "华盖");
            put("卯未", "华盖");
            put("辰辰", "华盖");
            put("巳丑", "华盖");
            put("午戌", "华盖");
            put("未未", "华盖");
            put("申辰", "华盖");
            put("酉丑", "华盖");
            put("戌戌", "华盖");
            put("亥未", "华盖");
        }
    };

    /**
     * 童子煞（季节+日支\时支为键。年柱纳音五行+日支\时支为键）
     */
    public static final Map<String, String> TONG_ZI_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以季节查日支\时支】春季见'寅\子'。夏季见'卯\未\辰'。秋季见'寅\子'。冬季见'卯\未\辰'。木见'午\卯'。火见'酉\戌'。土见'辰\巳'。金见'午\卯'。水见'酉\戌'

            二、详解：
                春季，并且日支\时支有寅\子
                夏季，并且日支\时支有卯\未\辰
                秋季，并且日支\时支有寅\子
                冬季，并且日支\时支有卯\未\辰
                年柱纳音五行为木，并且日支\时支有午\卯
                年柱纳音五行为火，并且日支\时支有酉\戌
                年柱纳音五行为土，并且日支\时支有辰\巳
                年柱纳音五行为金，并且日支\时支有午\卯
                年柱纳音五行为水，并且日支\时支有酉\戌
         */
        {
            put("春寅", "童子煞");
            put("春子", "童子煞");
            put("夏卯", "童子煞");
            put("夏未", "童子煞");
            put("夏辰", "童子煞");
            put("秋寅", "童子煞");
            put("秋子", "童子煞");
            put("冬卯", "童子煞");
            put("冬未", "童子煞");
            put("冬辰", "童子煞");
            put("木午", "童子煞");
            put("木卯", "童子煞");
            put("火酉", "童子煞");
            put("火戌", "童子煞");
            put("土辰", "童子煞");
            put("土巳", "童子煞");
            put("金午", "童子煞");
            put("金卯", "童子煞");
            put("水酉", "童子煞");
            put("水戌", "童子煞");
        }
    };

    /**
     * 四废日（月支+日干支为键）
     */
    public static final Map<String, String> SI_FEI_RI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'丙午\丁巳'。丑见'丙午\丁巳'。寅见'庚申\辛酉'。卯见'庚申\辛酉'。辰见'庚申\辛酉'。巳见'壬子\癸亥'。午见'壬子\癸亥'。未见'壬子\癸亥'。申见'甲寅\乙卯'。酉见'甲寅\乙卯'。戌见'甲寅\乙卯'。亥见'丙午\丁巳'

            二、详解：
                月支是子，并且日干支有丙午\丁巳
                月支是丑，并且日干支有丙午\丁巳
                月支是寅，并且日干支有庚申\辛酉
                月支是卯，并且日干支有庚申\辛酉
                月支是辰，并且日干支有庚申\辛酉
                月支是巳，并且日干支有壬子\癸亥
                月支是午，并且日干支有壬子\癸亥
                月支是未，并且日干支有壬子\癸亥
                月支是申，并且日干支有甲寅\乙卯
                月支是酉，并且日干支有甲寅\乙卯
                月支是戌，并且日干支有甲寅\乙卯
                月支是亥，并且日干支有丙午\丁巳
         */
        {
            put("子丙午", "四废日");
            put("子丁巳", "四废日");
            put("丑丙午", "四废日");
            put("丑丁巳", "四废日");
            put("寅庚申", "四废日");
            put("寅辛酉", "四废日");
            put("卯庚申", "四废日");
            put("卯辛酉", "四废日");
            put("辰庚申", "四废日");
            put("辰辛酉", "四废日");
            put("巳壬子", "四废日");
            put("巳癸亥", "四废日");
            put("午壬子", "四废日");
            put("午癸亥", "四废日");
            put("未壬子", "四废日");
            put("未癸亥", "四废日");
            put("申甲寅", "四废日");
            put("申乙卯", "四废日");
            put("酉甲寅", "四废日");
            put("酉乙卯", "四废日");
            put("戌甲寅", "四废日");
            put("戌乙卯", "四废日");
            put("亥丙午", "四废日");
            put("亥丁巳", "四废日");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 阴注阳受（月支+其余地支为键）
     */
    public static final Map<String, String> YIN_ZHU_YANG_SHOU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余地支】子见'子'。丑见'亥'。寅见'戌'。卯见'酉'。辰见'戌'。巳见'亥'。午见'子'。未见'丑'。申见'寅'。酉见'卯'。戌见'寅'。亥见'丑'

            二、详解：
                月支是子，并且其余地支有子
                月支是丑，并且其余地支有亥
                月支是寅，并且其余地支有戌
                月支是卯，并且其余地支有酉
                月支是辰，并且其余地支有戌
                月支是巳，并且其余地支有亥
                月支是午，并且其余地支有子
                月支是未，并且其余地支有丑
                月支是申，并且其余地支有寅
                月支是酉，并且其余地支有卯
                月支是戌，并且其余地支有寅
                月支是亥，并且其余地支有丑
         */
        {
            put("子子", "阴注阳受");
            put("丑亥", "阴注阳受");
            put("寅戌", "阴注阳受");
            put("卯酉", "阴注阳受");
            put("辰戌", "阴注阳受");
            put("巳亥", "阴注阳受");
            put("午子", "阴注阳受");
            put("未丑", "阴注阳受");
            put("申寅", "阴注阳受");
            put("酉卯", "阴注阳受");
            put("戌寅", "阴注阳受");
            put("亥丑", "阴注阳受");
        }
    };

    /**
     * 天罗地网（年支\日支+其余地支为键）
     */
    public static final Map<String, String> TIAN_LUO_DI_WANG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】辰见'巳'。巳见'辰'。戌见'亥'。亥见'戌'

            二、详解：
                年支\日支是辰，并且其余地支有巳
                年支\日支是巳，并且其余地支有辰
                年支\日支是戌，并且其余地支有亥
                年支\日支是亥，并且其余地支有戌
         */
        {
            put("辰巳", "天罗地网");
            put("巳辰", "天罗地网");
            put("戌亥", "天罗地网");
            put("亥戌", "天罗地网");
        }
    };

    /**
     * 空亡（年干支\日干支+其余地支为键）
     */
    public static final Map<String, String> KONG_WANG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干支\日干支查其余地支】

            二、详解：
                年干支\日干支是甲子，并且其余地支有戌
                年干支\日干支是乙丑，并且其余地支有戌
                年干支\日干支是丙寅，并且其余地支有戌
                年干支\日干支是丁卯，并且其余地支有戌
                年干支\日干支是戊辰，并且其余地支有戌
                年干支\日干支是己巳，并且其余地支有戌
                年干支\日干支是庚午，并且其余地支有戌
                年干支\日干支是辛未，并且其余地支有戌
                年干支\日干支是壬申，并且其余地支有戌
                年干支\日干支是癸酉，并且其余地支有戌
                年干支\日干支是甲子，并且其余地支有亥
                年干支\日干支是乙丑，并且其余地支有亥
                年干支\日干支是丙寅，并且其余地支有亥
                年干支\日干支是丁卯，并且其余地支有亥
                年干支\日干支是戊辰，并且其余地支有亥
                年干支\日干支是己巳，并且其余地支有亥
                年干支\日干支是庚午，并且其余地支有亥
                年干支\日干支是辛未，并且其余地支有亥
                年干支\日干支是壬申，并且其余地支有亥
                年干支\日干支是癸酉，并且其余地支有亥
                年干支\日干支是甲戌，并且其余地支有申
                年干支\日干支是乙亥，并且其余地支有申
                年干支\日干支是丙子，并且其余地支有申
                年干支\日干支是丁丑，并且其余地支有申
                年干支\日干支是戊寅，并且其余地支有申
                年干支\日干支是己卯，并且其余地支有申
                年干支\日干支是庚辰，并且其余地支有申
                年干支\日干支是辛巳，并且其余地支有申
                年干支\日干支是壬午，并且其余地支有申
                年干支\日干支是癸未，并且其余地支有申
                年干支\日干支是甲戌，并且其余地支有酉
                年干支\日干支是乙亥，并且其余地支有酉
                年干支\日干支是丙子，并且其余地支有酉
                年干支\日干支是丁丑，并且其余地支有酉
                年干支\日干支是戊寅，并且其余地支有酉
                年干支\日干支是己卯，并且其余地支有酉
                年干支\日干支是庚辰，并且其余地支有酉
                年干支\日干支是辛巳，并且其余地支有酉
                年干支\日干支是壬午，并且其余地支有酉
                年干支\日干支是癸未，并且其余地支有酉
                年干支\日干支是甲申，并且其余地支有午
                年干支\日干支是乙酉，并且其余地支有午
                年干支\日干支是丙戌，并且其余地支有午
                年干支\日干支是丁亥，并且其余地支有午
                年干支\日干支是戊子，并且其余地支有午
                年干支\日干支是己丑，并且其余地支有午
                年干支\日干支是庚寅，并且其余地支有午
                年干支\日干支是辛卯，并且其余地支有午
                年干支\日干支是壬辰，并且其余地支有午
                年干支\日干支是癸巳，并且其余地支有午
                年干支\日干支是甲申，并且其余地支有未
                年干支\日干支是乙酉，并且其余地支有未
                年干支\日干支是丙戌，并且其余地支有未
                年干支\日干支是丁亥，并且其余地支有未
                年干支\日干支是戊子，并且其余地支有未
                年干支\日干支是己丑，并且其余地支有未
                年干支\日干支是庚寅，并且其余地支有未
                年干支\日干支是辛卯，并且其余地支有未
                年干支\日干支是壬辰，并且其余地支有未
                年干支\日干支是癸巳，并且其余地支有未
                年干支\日干支是甲午，并且其余地支有辰
                年干支\日干支是乙未，并且其余地支有辰
                年干支\日干支是丙申，并且其余地支有辰
                年干支\日干支是丁酉，并且其余地支有辰
                年干支\日干支是戊戌，并且其余地支有辰
                年干支\日干支是己亥，并且其余地支有辰
                年干支\日干支是庚子，并且其余地支有辰
                年干支\日干支是辛丑，并且其余地支有辰
                年干支\日干支是壬寅，并且其余地支有辰
                年干支\日干支是癸卯，并且其余地支有辰
                年干支\日干支是甲午，并且其余地支有巳
                年干支\日干支是乙未，并且其余地支有巳
                年干支\日干支是丙申，并且其余地支有巳
                年干支\日干支是丁酉，并且其余地支有巳
                年干支\日干支是戊戌，并且其余地支有巳
                年干支\日干支是己亥，并且其余地支有巳
                年干支\日干支是庚子，并且其余地支有巳
                年干支\日干支是辛丑，并且其余地支有巳
                年干支\日干支是壬寅，并且其余地支有巳
                年干支\日干支是癸卯，并且其余地支有巳
                年干支\日干支是甲辰，并且其余地支有寅
                年干支\日干支是乙巳，并且其余地支有寅
                年干支\日干支是丙午，并且其余地支有寅
                年干支\日干支是丁未，并且其余地支有寅
                年干支\日干支是戊申，并且其余地支有寅
                年干支\日干支是己酉，并且其余地支有寅
                年干支\日干支是庚戌，并且其余地支有寅
                年干支\日干支是辛亥，并且其余地支有寅
                年干支\日干支是壬子，并且其余地支有寅
                年干支\日干支是癸丑，并且其余地支有寅
                年干支\日干支是甲辰，并且其余地支有卯
                年干支\日干支是乙巳，并且其余地支有卯
                年干支\日干支是丙午，并且其余地支有卯
                年干支\日干支是丁未，并且其余地支有卯
                年干支\日干支是戊申，并且其余地支有卯
                年干支\日干支是己酉，并且其余地支有卯
                年干支\日干支是庚戌，并且其余地支有卯
                年干支\日干支是辛亥，并且其余地支有卯
                年干支\日干支是壬子，并且其余地支有卯
                年干支\日干支是癸丑，并且其余地支有卯
                年干支\日干支是甲寅，并且其余地支有子
                年干支\日干支是乙卯，并且其余地支有子
                年干支\日干支是丙辰，并且其余地支有子
                年干支\日干支是丁巳，并且其余地支有子
                年干支\日干支是戊午，并且其余地支有子
                年干支\日干支是己未，并且其余地支有子
                年干支\日干支是庚申，并且其余地支有子
                年干支\日干支是辛酉，并且其余地支有子
                年干支\日干支是壬戌，并且其余地支有子
                年干支\日干支是癸亥，并且其余地支有子
                年干支\日干支是甲寅，并且其余地支有丑
                年干支\日干支是乙卯，并且其余地支有丑
                年干支\日干支是丙辰，并且其余地支有丑
                年干支\日干支是丁巳，并且其余地支有丑
                年干支\日干支是戊午，并且其余地支有丑
                年干支\日干支是己未，并且其余地支有丑
                年干支\日干支是庚申，并且其余地支有丑
                年干支\日干支是辛酉，并且其余地支有丑
                年干支\日干支是壬戌，并且其余地支有丑
                年干支\日干支是癸亥，并且其余地支有丑
         */
        {
            put("甲子戌", "空亡");
            put("乙丑戌", "空亡");
            put("丙寅戌", "空亡");
            put("丁卯戌", "空亡");
            put("戊辰戌", "空亡");
            put("己巳戌", "空亡");
            put("庚午戌", "空亡");
            put("辛未戌", "空亡");
            put("壬申戌", "空亡");
            put("癸酉戌", "空亡");
            put("甲子亥", "空亡");
            put("乙丑亥", "空亡");
            put("丙寅亥", "空亡");
            put("丁卯亥", "空亡");
            put("戊辰亥", "空亡");
            put("己巳亥", "空亡");
            put("庚午亥", "空亡");
            put("辛未亥", "空亡");
            put("壬申亥", "空亡");
            put("癸酉亥", "空亡");
            put("甲戌申", "空亡");
            put("乙亥申", "空亡");
            put("丙子申", "空亡");
            put("丁丑申", "空亡");
            put("戊寅申", "空亡");
            put("己卯申", "空亡");
            put("庚辰申", "空亡");
            put("辛巳申", "空亡");
            put("壬午申", "空亡");
            put("癸未申", "空亡");
            put("甲戌酉", "空亡");
            put("乙亥酉", "空亡");
            put("丙子酉", "空亡");
            put("丁丑酉", "空亡");
            put("戊寅酉", "空亡");
            put("己卯酉", "空亡");
            put("庚辰酉", "空亡");
            put("辛巳酉", "空亡");
            put("壬午酉", "空亡");
            put("癸未酉", "空亡");
            put("甲申午", "空亡");
            put("乙酉午", "空亡");
            put("丙戌午", "空亡");
            put("丁亥午", "空亡");
            put("戊子午", "空亡");
            put("己丑午", "空亡");
            put("庚寅午", "空亡");
            put("辛卯午", "空亡");
            put("壬辰午", "空亡");
            put("癸巳午", "空亡");
            put("甲申未", "空亡");
            put("乙酉未", "空亡");
            put("丙戌未", "空亡");
            put("丁亥未", "空亡");
            put("戊子未", "空亡");
            put("己丑未", "空亡");
            put("庚寅未", "空亡");
            put("辛卯未", "空亡");
            put("壬辰未", "空亡");
            put("癸巳未", "空亡");
            put("甲午辰", "空亡");
            put("乙未辰", "空亡");
            put("丙申辰", "空亡");
            put("丁酉辰", "空亡");
            put("戊戌辰", "空亡");
            put("己亥辰", "空亡");
            put("庚子辰", "空亡");
            put("辛丑辰", "空亡");
            put("壬寅辰", "空亡");
            put("癸卯辰", "空亡");
            put("甲午巳", "空亡");
            put("乙未巳", "空亡");
            put("丙申巳", "空亡");
            put("丁酉巳", "空亡");
            put("戊戌巳", "空亡");
            put("己亥巳", "空亡");
            put("庚子巳", "空亡");
            put("辛丑巳", "空亡");
            put("壬寅巳", "空亡");
            put("癸卯巳", "空亡");
            put("甲辰寅", "空亡");
            put("乙巳寅", "空亡");
            put("丙午寅", "空亡");
            put("丁未寅", "空亡");
            put("戊申寅", "空亡");
            put("己酉寅", "空亡");
            put("庚戌寅", "空亡");
            put("辛亥寅", "空亡");
            put("壬子寅", "空亡");
            put("癸丑寅", "空亡");
            put("甲辰卯", "空亡");
            put("乙巳卯", "空亡");
            put("丙午卯", "空亡");
            put("丁未卯", "空亡");
            put("戊申卯", "空亡");
            put("己酉卯", "空亡");
            put("庚戌卯", "空亡");
            put("辛亥卯", "空亡");
            put("壬子卯", "空亡");
            put("癸丑卯", "空亡");
            put("甲寅子", "空亡");
            put("乙卯子", "空亡");
            put("丙辰子", "空亡");
            put("丁巳子", "空亡");
            put("戊午子", "空亡");
            put("己未子", "空亡");
            put("庚申子", "空亡");
            put("辛酉子", "空亡");
            put("壬戌子", "空亡");
            put("癸亥子", "空亡");
            put("甲寅丑", "空亡");
            put("乙卯丑", "空亡");
            put("丙辰丑", "空亡");
            put("丁巳丑", "空亡");
            put("戊午丑", "空亡");
            put("己未丑", "空亡");
            put("庚申丑", "空亡");
            put("辛酉丑", "空亡");
            put("壬戌丑", "空亡");
            put("癸亥丑", "空亡");
        }
    };

    /**
     * 截空（日干+时支为键）
     */
    public static final Map<String, String> JIE_KONG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查时支】甲见'申\酉'。乙见'午\未'。丙见'辰\巳'。丁见'寅\卯'。戊见'子\丑'。己见'申\酉'。庚见'午\未'。辛见'辰\巳'。壬见'寅\卯'。癸见'子\丑'

            二、详解：
                日干是甲，并且时支有申\酉
                日干是乙，并且时支有午\未
                日干是丙，并且时支有辰\巳
                日干是丁，并且时支有寅\卯
                日干是戊，并且时支有子\丑
                日干是己，并且时支有申\酉
                日干是庚，并且时支有午\未
                日干是辛，并且时支有辰\巳
                日干是壬，并且时支有寅\卯
                日干是癸，并且时支有子\丑
         */
        {
            put("甲申", "截空");
            put("甲酉", "截空");
            put("乙午", "截空");
            put("乙未", "截空");
            put("丙辰", "截空");
            put("丙巳", "截空");
            put("丁寅", "截空");
            put("丁卯", "截空");
            put("戊子", "截空");
            put("戊丑", "截空");
            put("己申", "截空");
            put("己酉", "截空");
            put("庚午", "截空");
            put("庚未", "截空");
            put("辛辰", "截空");
            put("辛巳", "截空");
            put("壬寅", "截空");
            put("壬卯", "截空");
            put("癸子", "截空");
            put("癸丑", "截空");
        }
    };

    /**
     * 六厄（年支+其余地支为键）
     */
    public static final Map<String, String> LIU_E = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'卯'。丑见'子'。寅见'酉'。卯见'午'。辰见'卯'。巳见'子'。午见'酉'。未见'午'。申见'卯'。酉见'子'。戌见'酉'。亥见'午'

            二、详解：
                年支是子，并且其余地支有卯
                年支是丑，并且其余地支有子
                年支是寅，并且其余地支有酉
                年支是卯，并且其余地支有午
                年支是辰，并且其余地支有卯
                年支是巳，并且其余地支有子
                年支是午，并且其余地支有酉
                年支是未，并且其余地支有午
                年支是申，并且其余地支有卯
                年支是酉，并且其余地支有子
                年支是戌，并且其余地支有酉
                年支是亥，并且其余地支有午
         */
        {
            put("子卯", "六厄");
            put("丑子", "六厄");
            put("寅酉", "六厄");
            put("卯午", "六厄");
            put("辰卯", "六厄");
            put("巳子", "六厄");
            put("午酉", "六厄");
            put("未午", "六厄");
            put("申卯", "六厄");
            put("酉子", "六厄");
            put("戌酉", "六厄");
            put("亥午", "六厄");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 三奇贵人（年干+月干+日干\月干+日干+时干为键）
     */
    public static final Map<String, String> SAN_QI_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        {
            put("甲戊庚", "三奇贵人");
            put("甲庚戊", "三奇贵人");
            put("戊甲庚", "三奇贵人");
            put("戊庚甲", "三奇贵人");
            put("庚甲戊", "三奇贵人");
            put("庚戊甲", "三奇贵人");
            put("乙丙丁", "三奇贵人");
            put("乙丁丙", "三奇贵人");
            put("丙乙丁", "三奇贵人");
            put("丙丁乙", "三奇贵人");
            put("丁乙丙", "三奇贵人");
            put("丁丙乙", "三奇贵人");
            put("壬癸辛", "三奇贵人");
            put("壬辛癸", "三奇贵人");
            put("癸壬辛", "三奇贵人");
            put("癸辛壬", "三奇贵人");
            put("辛壬癸", "三奇贵人");
            put("辛癸壬", "三奇贵人");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 十恶大败（日干支）
     */
    public static final String[] SHI_E_DA_BAI = {"甲辰", "乙巳", "丙申", "丁亥", "戊戌", "己丑", "庚辰", "辛巳", "壬申", "癸亥"};

    /**
     * 阴差阳错（日干支）
     */
    public static final String[] YIN_CHA_YANG_CUO = {"丙午", "丙子", "丁未", "丁丑", "戊申", "戊寅", "辛酉", "辛卯", "壬戌", "壬辰", "癸巳", "癸亥"};

    /**
     * 孤鸾煞（日干支）
     */
    public static final String[] GU_LUAN_SHA = {"甲寅", "乙巳", "丙午", "丁巳", "戊午", "戊申", "辛亥", "壬子"};

    /**
     * 六秀日（日干支）
     */
    public static final String[] LIU_XIU_RI = {"丙午", "丁未", "戊子", "戊午", "己丑", "己未"};

    /**
     * 十灵日（日干支）
     */
    public static final String[] SHI_LING_RI = {"甲辰", "乙亥", "丙辰", "丁酉", "戊午", "庚戌", "庚寅", "辛亥", "壬寅", "癸未"};

    /**
     * 魁罡日（日干支）
     */
    public static final String[] KUI_GANG_RI = {"戊戌", "庚辰", "庚戌", "壬辰"};

    /**
     * 八专日（日干支）
     */
    public static final String[] BA_ZHUAN_RI = {"甲寅", "乙卯", "丁未", "戊戌", "己未", "庚申", "辛酉", "癸丑"};

    /**
     * 九丑日（日干支）
     */
    public static final String[] JIU_CHOU_RI = {"丁酉", "戊子", "戊午", "己卯", "己酉", "辛卯", "辛酉", "壬子", "壬午"};

    /**
     * 金神（日干支\时干支）
     */
    public static final String[] JIN_SHEN = {"乙丑", "己巳", "癸酉"};


}
